package edu.szcu.vitaguard.service.impl;

import edu.szcu.vitaguard.dao.PrescriptionDao;
import edu.szcu.vitaguard.dao.PrescriptionItemDao;
import edu.szcu.vitaguard.entity.Prescription;
import edu.szcu.vitaguard.entity.PrescriptionItem;
import edu.szcu.vitaguard.service.PrescriptionService;
import edu.szcu.vitaguard.vo.PageResult;
import edu.szcu.vitaguard.vo.PrescriptionQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

/**
 * 处方服务实现类
 */
@Service
public class PrescriptionServiceImpl implements PrescriptionService {

    @Autowired
    private PrescriptionDao prescriptionDao;

    @Autowired
    private PrescriptionItemDao prescriptionItemDao;

    /**
     * 分页查询处方列表
     *
     * @param query 查询条件
     * @return 分页结果
     */
    @Override
    public PageResult<Prescription> listPrescriptions(PrescriptionQuery query) {
        // 查询总记录数
        Long total = (long) prescriptionDao.selectCountByQuery(query);
        
        // 如果总记录数为0，直接返回空结果
        if (total == 0) {
            return new PageResult<>(0L, 0, query.getPageNum(), query.getPageSize(), null);
        }
        
        // 计算总页数
        int pages = (int) Math.ceil((double) total / query.getPageSize());
        
        // 查询当前页数据
        List<Prescription> list = prescriptionDao.selectByPage(query);
        
        // 返回分页结果
        return new PageResult<>(total, pages, query.getPageNum(), query.getPageSize(), list);
    }

    /**
     * 根据ID查询处方详情
     *
     * @param prescriptionId 处方ID
     * @return 处方详情
     */
    @Override
    public Prescription getPrescriptionById(Integer prescriptionId) {
        // 查询处方基本信息
        Prescription prescription = prescriptionDao.selectById(prescriptionId);
        
        if (prescription != null) {
            // 查询处方项目列表
            List<PrescriptionItem> items = prescriptionItemDao.selectByPrescriptionId(prescriptionId);
            prescription.setPrescriptionItems(items);
        }
        
        return prescription;
    }

    /**
     * 添加处方
     *
     * @param prescription 处方信息
     * @return 添加结果
     */
    @Override
    @Transactional
    public Integer addPrescription(Prescription prescription) {
        // 设置创建时间
        prescription.setCreateTime(java.time.LocalDateTime.now());
        
        // 设置处方状态为未发药
        prescription.setStatus("0");
        
        // 插入处方基本信息
        int result = prescriptionDao.insert(prescription);
        
        // 如果处方基本信息插入成功，并且有处方项目
        if (result > 0 && prescription.getPrescriptionItems() != null && !prescription.getPrescriptionItems().isEmpty()) {
            // 遍历处方项目列表
            for (PrescriptionItem item : prescription.getPrescriptionItems()) {
                // 设置处方ID
                item.setPrescriptionId(prescription.getPrescriptionId());
                // 插入处方项目
                prescriptionItemDao.insert(item);
            }
        }
        
        return result > 0 ? prescription.getPrescriptionId() : null;
    }

    /**
     * 更新处方
     *
     * @param prescription 处方信息
     * @return 更新结果
     */
    @Override
    @Transactional
    public boolean updatePrescription(Prescription prescription) {
        // 设置更新时间
        prescription.setUpdateTime(java.time.LocalDateTime.now());
        
        // 更新处方基本信息
        int result = prescriptionDao.update(prescription);
        
        // 如果处方基本信息更新成功，并且有处方项目
        if (result > 0 && prescription.getPrescriptionItems() != null && !prescription.getPrescriptionItems().isEmpty()) {
            // 先删除原有的处方项目
            prescriptionItemDao.deleteByPrescriptionId(prescription.getPrescriptionId());
            
            // 遍历处方项目列表
            for (PrescriptionItem item : prescription.getPrescriptionItems()) {
                // 设置处方ID
                item.setPrescriptionId(prescription.getPrescriptionId());
                // 插入处方项目
                prescriptionItemDao.insert(item);
            }
        }
        
        return result > 0;
    }

    /**
     * 删除处方
     *
     * @param prescriptionId 处方ID
     * @return 删除结果
     */
    @Override
    @Transactional
    public boolean deletePrescription(Integer prescriptionId) {
        // 先删除处方项目
        prescriptionItemDao.deleteByPrescriptionId(prescriptionId);
        
        // 再删除处方基本信息
        int result = prescriptionDao.deleteById(prescriptionId);
        
        return result > 0;
    }

    /**
     * 发药
     *
     * @param prescriptionId 处方ID
     * @return 发药结果
     */
    @Override
    public boolean dispense(Integer prescriptionId) {
        // 直接更新状态和发药时间
        int result = prescriptionDao.updateStatusAndDispenseTime(
            prescriptionId, 
            "1", 
            java.time.LocalDateTime.now()
        );
        return result > 0;
    }

    /**
     * 退药
     *
     * @param prescriptionId 处方ID
     * @return 退药结果
     */
    @Override
    public boolean returnMedicine(Integer prescriptionId) {
        // 直接更新状态和退药时间
        int result = prescriptionDao.updateStatusAndReturnTime(
            prescriptionId,
            "2",
            java.time.LocalDateTime.now()
        );
        return result > 0;
    }

    /**
     * 根据患者ID查询处方列表
     *
     * @param patientId 患者ID
     * @return 处方列表
     */
    @Override
    public List<Prescription> listPrescriptionsByPatientId(Integer patientId) {
        return prescriptionDao.selectByPatientId(patientId);
    }

    /**
     * 根据医生ID查询处方列表
     *
     * @param doctorId 医生ID
     * @return 处方列表
     */
    @Override
    public List<Prescription> listPrescriptionsByDoctorId(Integer doctorId) {
        return prescriptionDao.selectByDoctorId(doctorId);
    }

    /**
     * 根据就诊记录ID查询处方
     *
     * @param visitId 就诊记录ID
     * @return 处方信息
     */
    @Override
    public Prescription getPrescriptionByVisitId(Integer visitId) {
        List<Prescription> prescriptions = prescriptionDao.selectByVisitId(visitId);
        return prescriptions != null && !prescriptions.isEmpty() ? prescriptions.get(0) : null;
    }

    /**
     * 添加处方项
     *
     * @param prescriptionItem 处方项信息
     * @return 添加成功返回处方项ID，失败返回null
     */
    @Override
    @Transactional
    public Integer addPrescriptionItem(PrescriptionItem prescriptionItem) {
        int result = prescriptionItemDao.insert(prescriptionItem);
        return result > 0 ? prescriptionItem.getItemId() : null;
    }

    /**
     * 更新处方项
     *
     * @param prescriptionItem 处方项信息
     * @return 更新成功返回true，失败返回false
     */
    @Override
    @Transactional
    public boolean updatePrescriptionItem(PrescriptionItem prescriptionItem) {
        int result = prescriptionItemDao.update(prescriptionItem);
        return result > 0;
    }

    /**
     * 删除处方项
     *
     * @param itemId 处方项ID
     * @return 删除成功返回true，失败返回false
     */
    @Override
    @Transactional
    public boolean deletePrescriptionItem(Integer itemId) {
        int result = prescriptionItemDao.deleteById(itemId);
        return result > 0;
    }

    /**
     * 根据处方ID查询处方项列表
     *
     * @param prescriptionId 处方ID
     * @return 处方项列表
     */
    @Override
    public List<PrescriptionItem> listPrescriptionItemsByPrescriptionId(Integer prescriptionId) {
        return prescriptionItemDao.selectByPrescriptionId(prescriptionId);
    }
}
